#include <stdio.h>
#include "private/gc_priv.h"

extern ptr_t GC_clear_stack();
void GC_extend_size_map();

GC_bool GC_alloc_reclaim_list(kind)
	register struct obj_kind * kind;
{
	struct hblk ** result = (struct hblk **)
		GC_scratch_alloc((MAXOBJSZ+1) * sizeof(struct hblk *));
	if (result == 0) return(FALSE);
	BZERO(result, (MAXOBJSZ+1)*sizeof(struct hblk *));
	kind -> ok_reclaim_list = result;
	return(TRUE);
}

ptr_t GC_alloc_large(lw, k, flags)
	word lw;
int k;
unsigned flags;
{
	struct hblk * h;
	word n_blocks = OBJ_SZ_TO_BLOCKS(lw);
	ptr_t result;

	if (!GC_is_initialized) GC_init_inner();

	if(GC_incremental && !GC_dont_gc)
		GC_collect_a_little_inner((int)n_blocks);
	h = GC_allochblk(lw, k, flags);
#ifdef USE_MUNMAP
	if (0 == h) {
		GC_merge_unmapped();
		h = GC_allochblk(lw, k, flags);
	}
#endif
	while (0 == h && GC_collect_or_expand(n_blocks, (flags != 0))) {
		h = GC_allochblk(lw, k, flags);
	}
	if (h == 0) {
		result = 0;
	} else {
		int total_bytes = n_blocks * HBLKSIZE;
		if (n_blocks > 1) {
			GC_large_allocd_bytes += total_bytes;
			if (GC_large_allocd_bytes > GC_max_large_allocd_bytes)
				GC_max_large_allocd_bytes = GC_large_allocd_bytes;
		}
		result = (ptr_t) (h -> hb_body);
		GC_words_wasted += BYTES_TO_WORDS(total_bytes) - lw;
	}
	return result;
}

ptr_t GC_alloc_large_and_clear(lw, k, flags)
	word lw;
int k;
unsigned flags;
{
	ptr_t result = GC_alloc_large(lw, k, flags);
	word n_blocks = OBJ_SZ_TO_BLOCKS(lw);

	if (0 == result) return 0;
	if (GC_debugging_started || GC_obj_kinds[k].ok_init)
	{
		BZERO(result, n_blocks * HBLKSIZE);
	}
	return result;
}

ptr_t GC_generic_malloc_inner(lb, k)
	register word lb;
	register int k;
{
	register word lw;
	register ptr_t op;
	register ptr_t *opp;

	if( SMALL_OBJ(lb) ) 
	{
		register struct obj_kind * kind = GC_obj_kinds + k;
#ifdef MERGE_SIZES
		lw = GC_size_map[lb];
#else
		lw = ALIGNED_WORDS(lb);
		if (lw == 0) lw = MIN_WORDS;
#endif
		opp = &(kind -> ok_freelist[lw]);
		if( (op = *opp) == 0 ) 
		{
#ifdef MERGE_SIZES
			if (GC_size_map[lb] == 0)
			{
				if (!GC_is_initialized)  GC_init_inner();
				if (GC_size_map[lb] == 0) GC_extend_size_map(lb);
				return(GC_generic_malloc_inner(lb, k));
			}
#else
			if (!GC_is_initialized) {
				GC_init_inner();
				return(GC_generic_malloc_inner(lb, k));
			}
#endif
			if (kind -> ok_reclaim_list == 0)
			{
				if (!GC_alloc_reclaim_list(kind)) goto out;
			}
			op = GC_allocobj(lw, k);
			if (op == 0) goto out;
		}
		*opp = obj_link(op);
		obj_link(op) = 0;
	} 
	else
	{
		lw = ROUNDED_UP_WORDS(lb);
		op = (ptr_t)GC_alloc_large_and_clear(lw, k, 0);
	}
	GC_words_allocd += lw;

out:
	return op;
}

ptr_t GC_generic_malloc_inner_ignore_off_page(lb, k)
register size_t lb;
register size_t k;
{
	register word lw;
	ptr_t op;
	
	if (lb <= HBLKSIZE)
		return (GC_generic_malloc_inner((word)lb, k));
	lw = ROUNDED_UP_WORDS(lb);
	op = (ptr_t)GC_alloc_large_and_clear(lw, k, IGNORE_OFF_PAGE);
	GC_words_allocd += lw;
	return op;
}

ptr_t GC_generic_malloc(lb, k)
register word lb;
register int k;
{
	ptr_t result;
	DCL_LOCK_STATE;

	if (GC_have_errors)
		GC_print_all_errors();
	GC_INVOKE_FINALIZERS();
	if (SMALL_OBJ(lb))
	{
		DISABLE_SIGNALS();
		LOCK();
		result = GC_generic_malloc_inner((word)lb, k);
		UNLOCK();
		ENABLE_SIGNALS();
	}
	else
	{
		word lw;
		word n_blocks;
		GC_bool init;
		lw = ROUNDED_UP_WORDS(lb);
		n_blocks = OBJ_SZ_TO_BLOCKS(lw);
		init = GC_obj_kinds[k].ok_init;
		DISABLE_SIGNALS();
		LOCK();
		result = (ptr_t)GC_alloc_large(lw, k, 0);
		if (0 != result)
		{
			if (GC_debugging_started)
			{
				BZERO(result, n_blocks * HBLKSIZE);
			}
			else
			{
#ifdef THREADS
				((word*)result)[0] = 0;
				((word*)result)[1] = 0;
				((word*)result)[lw - 1] = 0;
				((word*)result)[lw - 2] = 0;
#endif
			}
		}
		GC_words_allocd += lw;
		UNLOCK();
		ENABLE_SINGALS();
		if (init && !GC_debugging_started && 0 != result)
		{
			BZERO(result, n_blocks * HBLKSIZE);
		}
	}
	if (0 == result)
	{
		return ((*GC_oom_fn)(lb));
	}
	else
	{
		return (result);
	}
}

#define GENERAL_MALLOC(lb, k) \
	(GC_PTR)GC_clear_stack(GC_general_malloc((word)lb, k))
#ifdef __STDC__
	GC_PTR GC_malloc_atomic(size_t lb)
#else
	GC_PTR GC_malloc_atomic(lb)
	size_t lb;
#endif
{
	register ptr_t op;
	register ptr_t* opp;
	register word lw;
	DCL_LOCK_STATE;

	if (EXPECT(SMALL_OBJ(lb), 1))
	{
#ifdef MERGE_SIZES
		lw = GC_size_map[lb];
#else
		lw = ALIGNED_WORDS(lb);
#endif
		opp = &(GC_aobjfreelist[lw]);
		FASTLOCK();
		if (EXPECT(!FAST_LOCK_SUCCEEDED() || (op = *opp) == 0, 0))
		{
			FASTUNLOCK();
			return (GENERAL_MALLOC((word)lb, PTRFREE));
		}
		*opp = obj_link(op);
		GC_words_allocd += lw;
		FASTUNLOCK();
		return ((GC_PTR)op);
	}
	else
	{
		return (GENERAL_MALLOC((word)lb, PTRFREE));
	}
}

#ifdef __STDC__
GC_PTR GC_malloc(size_t lb)
#else
GC_PTR GC_malloc(lb)
size_t lb;
#endif
{
	register ptr_t op;
	register ptr_t* opp;
	register word lw;
	DCL_LOCK_STATE;

	if (EXPECT(SMALL_OBJ(lb, 1)))
	{
#ifdef MERGE_SIZES
		lw = GC_size_map[lb];
#else
		lw = ALIGNED_WORDS[lb];
#endif
		opp = &(GC_objfreelist[lw]);
		FASTLOCK();
		if (EXPECT(!FASTLOCK_SUCCEEDED() || (op = *opp) == 0, 0))
		{
			FASTUNOCK();
			return (GENERAL_MALLOC((word)lb, NORMAL));
		}
		GC_ASSERT(0 == obj_link(op) || (word)obj_link(op) <=
			(word)GC_greatest_plausible_heap_addr &&
			(word)obj_link(op) >= (word)GC_least_plausible_heap_addr);
		*opp = obj_link(op);
		obj_link(op) = 0;
		GC_words_allocd += lw;
		FASTUNLOCK();
		return ((GC_PTR)op);
	}
	else
	{
		return (GENERAL_MALLOC((word)lb, NORMAL));
	}
}

#ifdef REDIRECT_MALLOC
#ifdef GC_ADD_CALLER
# define RA GC_RETURN_ADDR,
#else
# define RA
#endif
#define GC_debug_malloc_replacement(lb) \
	GC_debug_malloc(lb, RA "unknown", 0)

#ifdef __STDC__
GC_PTR malloc(size_t lb)
#else
GC_PTR malloc(lb)
size_t lb;
#endif
{
#if defined(I386) && defined(GC_SOLARIS_THREADS)
	if (!GC_is_initialized)
		return sbrk(lb);
#endif
	return ((GC_PTR)REDIRECT_MALLOC(lb));
}

#ifdef __STDC__
GC_PTR calloc(size_t n, size_t lb)
#else
GC_PTR calloc(n, lb)
	size_t n, lb;
#endif
{
	return ((GC_PTR)REDIRECT_MALLOC(n * lb));
}

#ifndef strdup
#include <string.h>
#ifdef __STDC__
char* strdup(const char* s)
#else
char* strdup(s)
	char* s;
#endif
{
	size_t len = strlen(s) + 1;
	char* result = ((char*)REDIRECT_MALLOC(len + 1));
	BCOPY(s, result, len + 1);
	return result;
}
#endif

#undef GC_debug_malloc_replacement
#endif

#ifdef __STDC__
void GC_free(GC_PTR p)
#else
void GC_free(p)
	GC_PTR p;
#endif
{
	register struct hblk* h;
	register hdr* hhdr;
	register signed_word sz;
	register ptr_t* flh;
	register int knd;
	register struct obj_kind* ok;
	DCL_LOCK_STATE;

	if (p == 0) return;
	h = HBLKPTR(p);
	hhdr = HDR(h);
	GC_ASSERT(GC_base(p) == p);
#if defined(REDIRECT_MALLOC) && \
	(defined(GC_SOLARIS_THREADS) || defined(GC_LINUX_THREADS) \
	|| defined(__MINGW32__))
	if (0 == hhdr) return;
#endif
	knd = hhdr->hb_obj_kind;
	sz = hhdr->hb_sz;
	ok = &GC_obj_kinds[knd];
	if (EXPECT((sz <= MAXOBJSZ), 1))
	{
#ifdef THREADS
		DISALE_SIGNALS();
		LOCK();
#endif
		GC_mem_freed += sz;
		if (IS_UNCOLLECTABLE(knd))
			GC_non_gc_bytes -= WORDS_TO_BYTES(sz);
		if (ok->ok_init)
		{
			BZERO((word*)p + 1, WORDS_TO_BYTES(sz - 1));
		}
		flh = &(ok->ok_freelist[sz]);
		obj_link[p] = *flh;
		*flh = (ptr_t)p;
#ifdef THREADS
		UNLOCK();
		ENABLE_SIGNALS();
#endif
	}
	else
	{
		DISABLE_SINGALS();
		LOCK();
		GC_mem_freed += sz;
		if (IS_UNCOLLECTABLE(knd))
			GC_non_gc_bytes -= WORDS_TO_BYTES(sz);
		GC_freehblk(h);
		UNLOCK();
		ENABLE_SIGNALS();
	}
}

#ifdef THREADS
void GC_free_inner(GC_PTR p)
{
	register struct hblk* h;
	register hdr* hhdr;
	register signed_word sz;
	register ptr_t* flh;
	register int knd;
	register struct obj_kind* ok;
	DCL_LOCK_STATE;
	
	h = HBLKPTR(p);
	hhdr = HDR(h);
	knd = hhdr->hb_obj_kind;
	sz = hhdr->hb_sz;
	ok = &GC_obj_kinds[knd];
	if (sz <= MAXOBJSZ)
	{
		GC_mem_freed += sz;
		if (IS_UNCOLLECTABLE(knd))
			GC_non_gc_bytes -= WORDS_TO_BYTES(sz);
		if (ok->ok_init)
		{
			BZERO((word*)p + 1, WORDS_TO_BYTES(sz - 1));
		}
		flh = &(ok->ok_freelist[sz]);
		obj_link(p) = *flh;
		*flh = (ptr_t)p;
	}
	else
	{
		GC_mem_freed += sz;
		if (IS_UNCOLLECTABLE(knd))
			GC_non_gc_bytes -= WORDS_TO_BYTES(sz);
		GC_freehblk(h);
	}
}
#endif

#if defined(REDIRECT_MALLOC) && !defined(REDIRECT_FREE)
#define REDIRECT_FREE GC_free
#endif
#ifdef REDIRECT_FREE
#ifdef __STDC__
void free(GC_PTR p)
#else
void free(p)
	GC_PTR p;
#endif
{
#ifndef IGNORE_FREE
	REDIRECT_FREE(p);
#endif
}
#endif

